home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / memory / memman2b / bigarray.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-19  |  3.2 KB  |  111 lines
  1. /************************* BigArray.hpp *******************************
  2.   This is the header that contains the class definition for BigArray.
  3. ***********************************************************************/
  4.  
  5. #ifndef __BIGARRAY_H
  6. #define __BIGARRAY_H
  7.  
  8. extern "C" {
  9.     #include "memory.h"
  10. };
  11.  
  12. class BigArray {
  13.  
  14.     private:
  15.  
  16.     long            offset;        //  currently accessed byte in array
  17.     long            Item;       //  currently accessed item in array
  18.     int             step;        //  Size of step to take
  19.     unsigned        Line;       //  Currently accessed line from buffer
  20.  
  21.     byte            status;     //  Error indicator
  22.  
  23.     mem_hand        Handle;        //  handle of this array
  24.     unsigned        Lines;        //  number of lines in array
  25.     unsigned        Width;        //  size of each line in array
  26.     long            Items;      //  Number of items in array
  27.     unsigned long   ArraySize;    //  total array size
  28.     byte far       *LineBuf;    //  pointer to current line of array
  29.  
  30.     public:
  31.  
  32.     /***    Constructor defaults to using Extended, then Expanded,
  33.             then Conventional, then Virtual
  34.  
  35.             Defaults to an array of bytes, but can be called with
  36.             an optional second parameter declaring the size of
  37.             each element, eg:
  38.  
  39.             BigArray MyArray(1000,sizeof(mystruct))
  40.     ***/
  41.     BigArray( long          NElements,
  42.               unsigned int  ElementSize=1,
  43.               char         *AllocStrategy="XECV");
  44.  
  45.     /***    Destructor is simple enough
  46.     ***/
  47.     ~BigArray();
  48.  
  49.     /***    Check to see if error - should be called for
  50.             each attempted allocation
  51.     ***/
  52.     int     OK(void);
  53.  
  54.     /***    Report on type of memory allocated
  55.     ***/
  56.     char   *Type(void);
  57.  
  58.     /***    Return a pointer to the current element.
  59.             This can then be cast to the data type being allocated,
  60.  
  61.             structptr = (struct mystruct *)*MyArray
  62.  
  63.             or used to store a new value:
  64.  
  65.             (struct mystruct *)*MyArray->MyElement = 45;
  66.     /**/
  67.     byte * operator*(void);
  68.  
  69.     /***    Return a pointer to the given element, and positions
  70.             the array there.
  71.  
  72.             This can then be cast to the data type being allocated,
  73.  
  74.             structptr = (struct mystruct *)MyArray[1042];
  75.  
  76.             or used to store a new value:
  77.  
  78.             (struct mystruct *)MyArray[1042]->MyElement = 6;
  79.     /**/
  80.     byte * operator[](unsigned long i);
  81.  
  82.     /***    Increment and Decrement the current element
  83.             (Advances ElementSize bytes at a time)
  84.             Returns false on error
  85.     ***/
  86.     int  operator++(void);
  87.     int  operator--(void);
  88.  
  89.     /***    Logical status indicator - returns status after last
  90.             operation
  91.     ***/
  92.     int operator!(void);
  93.  
  94.     /***    Feed in bytes sequentially, and pull out bytes sequentially.
  95.  
  96.             Note that after a ++, -- or [] operation, the array
  97.             will be positioned at the first byte of the given element,
  98.             and subsequent << >> ops will move from here one byte at
  99.             a time.
  100.  
  101.             The Current Element will only be changed once you have moved
  102.             ElementSize bytes in this fashion.
  103.  
  104.             Both return -1 on error
  105.     ***/
  106.     int  operator<<(byte);
  107.     int  operator>>(byte &recipient);
  108. };
  109.  
  110. #endif  /* __BIGARRAY_H */
  111.